﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Data;
using Entity;

namespace Business
{
    /// <summary>
    /// Ce service gère les relations d'amitiées entre les utilisateurs.
    /// </summary>
    public class AmisService
    {

        /// <summary>
        /// Ajoute une demande d'ajout d'amis en provenance de iddemandeur pour idreceveur.
        /// </summary>
        /// <param name="iddemandeur">L'utilisateur à l'origine de la demande</param>
        /// <param name="idreceveur">L'utilisateur faisant l'objet de la demande</param>
        public static void demandeAmitie(int iddemandeur, int idreceveur)
        {
            AmitieData.ajouterAmitie(iddemandeur, idreceveur, AmitieEtat.DEMANDEUR);
            AmitieData.ajouterAmitie(idreceveur, iddemandeur, AmitieEtat.RECEVEUR);
        }

        /// <summary>
        /// Confirmation de demande d'ajout en provenance de iddemandeur par idreceveur.
        /// </summary>
        /// <param name="idreceveur">L'utilisateur ayant confirmé la demande</param>
        /// <param name="iddemandeur">L'utilisateur à l'origine de la demande</param>
        /// </param>
        public static void confirmerDemande(int iddemandeur, int idreceveur)
        {
            AmitieData.majAmitie(idreceveur, iddemandeur, AmitieEtat.AMIS);
            AmitieData.majAmitie(iddemandeur, idreceveur, AmitieEtat.AMIS);
        }

        /// <summary>
        /// Refus de la demande d'ajout en provenance de iddemandeur par idreceveur.
        /// </summary>
        /// <param name="idreceveur">L'utilisateur ayant ignoré la demande</param>
        /// <param name="iddemandeur">L'utilisateur à l'origine de la demande</param>
        /// </param>
        public static void ignorerDemande(int iddemandeur, int idreceveur)
        {
            AmitieData.supprimerAmitie(iddemandeur, idreceveur);
            AmitieData.supprimerAmitie(idreceveur, iddemandeur);
        }

        /// <summary>
        /// Met fin à une relation d'amitié entre deux utilisateurs.
        /// </summary>
        /// <param name="idutilisateur">L'utilisateur à la source de la fin de la relation</param>
        /// <param name="idamis">L'autre utilisateur de la relation</param>
        public static void supprimerAmitie(int idutilisateur, int idamis)
        {
            AmitieData.supprimerAmitie(idutilisateur, idamis);
            AmitieData.supprimerAmitie(idamis, idutilisateur);
        }

        /// <summary>
        /// Retourne, si elle existe, la relation d'amitié entre les deux utilisateurs.
        /// </summary>
        /// <param name="idutilisateur">L'utilisateur source de la relation</param>
        /// <param name="idamis">L'utilisateur cible de la relation</param>
        /// <returns>La relation d'amitié, ou null si elle n'existe pas</returns>
        public static AmitieUtilisateur getAmitie(int idutilisateur, int idamis)
        {
            AmitieUtilisateur amitie = new AmitieUtilisateur
            {
                Amitie = AmitieData.getAmitie(idutilisateur, idamis),
                Utilisateur = UtilisateurData.getUtilisateur(idamis)
            };

            if (amitie.Amitie != null && amitie.Utilisateur != null)
                return amitie;
            else
                return null;
        }

        /// <summary>
        /// Retourne tous les amis d'un utilisateur donné.
        /// </summary>
        /// <param name="idutilisateur">L'utilisateur dont on veut connaitre les amis</param>
        /// <returns>La liste des amis de l'utilisateur, ou null si aucune amitié</returns>
        public static List<AmitieUtilisateur> getAmities(int idutilisateur)
        {
            return AmitieData.getAmities(idutilisateur, AmitieEtat.AMIS);
        }

        /// <summary>
        /// Retourne toutes les demandes d'ajout d'un utilisateur donné.
        /// </summary>
        /// <param name="idutilisateur">L'utilisateur dont on veut connaitre les demandes</param>
        /// <returns>La liste des demandes d'ajout de l'utilisateur, ou null si aucune demande</returns>
        public static List<AmitieUtilisateur> getDemandeAjout(int idutilisateur)
        {
            return AmitieData.getAmities(idutilisateur, AmitieEtat.RECEVEUR);
        }

        /// <summary>
        /// Retourne tous les relations d'amitié d'un utilisateur donné.
        /// </summary>
        /// <param name="idutilisateur">L'utilisateur dont on veut connaitre les relations</param>
        /// <returns>La liste des relations de l'utilisateur, ou null si aucune amitié</returns>
        public static List<AmitieUtilisateur> getRelations(int idutilisateur)
        {
            List<AmitieUtilisateur> relations = new List<AmitieUtilisateur>();
            List<AmitieUtilisateur> amities;

            amities = AmitieData.getAmities(idutilisateur, AmitieEtat.AMIS);
            if (amities != null)
                relations.AddRange(amities);

            amities = AmitieData.getAmities(idutilisateur, AmitieEtat.DEMANDEUR);
            if (amities != null)
                relations.AddRange(amities);

            amities = AmitieData.getAmities(idutilisateur, AmitieEtat.RECEVEUR);
            if (amities != null)
                relations.AddRange(amities);

            return relations;
        }

    }
}
